/*
 * Copyright (c) 2004-2006 Derelict Developers
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the names 'Derelict', 'DerelictGL', nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
module derelict.opengl.gl13;

private
{
    import derelict.util.loader;
    import derelict.util.exception;
    import derelict.opengl.gltypes;
    version(Windows)
        import derelict.opengl.wgl;
}

package void loadGL13(SharedLib lib)
{
    version(Windows)
    {
        wglBindFunc(cast(void**)&glActiveTexture, "glActiveTexture", lib);
        wglBindFunc(cast(void**)&glClientActiveTexture, "glClientActiveTexture", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1d, "glMultiTexCoord1d", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1dv, "glMultiTexCoord1dv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1f, "glMultiTexCoord1f", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1fv, "glMultiTexCoord1fv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1i, "glMultiTexCoord1i", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1iv, "glMultiTexCoord1iv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1s, "glMultiTexCoord1s", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord1sv, "glMultiTexCoord1sv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2d, "glMultiTexCoord2d", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2dv, "glMultiTexCoord2dv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2f, "glMultiTexCoord2f", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2fv, "glMultiTexCoord2fv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2i, "glMultiTexCoord2i", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2iv, "glMultiTexCoord2iv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2s, "glMultiTexCoord2s", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord2sv, "glMultiTexCoord2s", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3d, "glMultiTexCoord3d", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3dv, "glMultiTexCoord3d", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3f, "glMultiTexCoord3f", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3fv, "glMultiTexCoord3fv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3i, "glMultiTexCoord3i", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3iv, "glMultiTexCoord3iv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3s, "glMultiTexCoord3s", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord3sv, "glMultiTexCoord3sv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4d, "glMultiTexCoord4d", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4dv, "glMultiTexCoord4dv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4f, "glMultiTexCoord4f", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4fv, "glMultiTexCoord4fv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4i, "glMultiTexCoord4i", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4iv, "glMultiTexCoord4iv", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4s, "glMultiTexCoord4s", lib);
        wglBindFunc(cast(void**)&glMultiTexCoord4sv, "glMultiTexCoord4sv", lib);
        wglBindFunc(cast(void**)&glLoadTransposeMatrixd, "glLoadTransposeMatrixd", lib);
        wglBindFunc(cast(void**)&glLoadTransposeMatrixf, "glLoadTransposeMatrixf", lib);
        wglBindFunc(cast(void**)&glMultTransposeMatrixd, "glMultTransposeMatrixd", lib);
        wglBindFunc(cast(void**)&glMultTransposeMatrixf, "glMultTransposeMatrixf", lib);
        wglBindFunc(cast(void**)&glSampleCoverage, "glSampleCoverage", lib);
        wglBindFunc(cast(void**)&glCompressedTexImage1D, "glCompressedTexImage1D", lib);
        wglBindFunc(cast(void**)&glCompressedTexImage2D, "glCompressedTexImage2D", lib);
        wglBindFunc(cast(void**)&glCompressedTexImage3D, "glCompressedTexImage3D", lib);
        wglBindFunc(cast(void**)&glCompressedTexSubImage1D, "glCompressedTexSubImage1D", lib);
        wglBindFunc(cast(void**)&glCompressedTexSubImage2D, "glCompressedTexSubImage2D", lib);
        wglBindFunc(cast(void**)&glCompressedTexSubImage3D, "glCompressedTexSubImage3D", lib);
        wglBindFunc(cast(void**)&glGetCompressedTexImage, "glGetCompressedTexImage", lib);
    }
    else
    {
        bindFunc(glActiveTexture)("glActiveTexture", lib);
        bindFunc(glClientActiveTexture)("glClientActiveTexture", lib);
        bindFunc(glMultiTexCoord1d)("glMultiTexCoord1d", lib);
        bindFunc(glMultiTexCoord1dv)("glMultiTexCoord1dv", lib);
        bindFunc(glMultiTexCoord1f)("glMultiTexCoord1f", lib);
        bindFunc(glMultiTexCoord1fv)("glMultiTexCoord1fv", lib);
        bindFunc(glMultiTexCoord1i)("glMultiTexCoord1i", lib);
        bindFunc(glMultiTexCoord1iv)("glMultiTexCoord1iv", lib);
        bindFunc(glMultiTexCoord1s)("glMultiTexCoord1s", lib);
        bindFunc(glMultiTexCoord1sv)("glMultiTexCoord1sv", lib);
        bindFunc(glMultiTexCoord2d)("glMultiTexCoord2d", lib);
        bindFunc(glMultiTexCoord2dv)("glMultiTexCoord2dv", lib);
        bindFunc(glMultiTexCoord2f)("glMultiTexCoord2f", lib);
        bindFunc(glMultiTexCoord2fv)("glMultiTexCoord2fv", lib);
        bindFunc(glMultiTexCoord2i)("glMultiTexCoord2i", lib);
        bindFunc(glMultiTexCoord2iv)("glMultiTexCoord2iv", lib);
        bindFunc(glMultiTexCoord2s)("glMultiTexCoord2s", lib);
        bindFunc(glMultiTexCoord2sv)("glMultiTexCoord2s", lib);
        bindFunc(glMultiTexCoord3d)("glMultiTexCoord3d", lib);
        bindFunc(glMultiTexCoord3dv)("glMultiTexCoord3d", lib);
        bindFunc(glMultiTexCoord3f)("glMultiTexCoord3f", lib);
        bindFunc(glMultiTexCoord3fv)("glMultiTexCoord3fv", lib);
        bindFunc(glMultiTexCoord3i)("glMultiTexCoord3i", lib);
        bindFunc(glMultiTexCoord3iv)("glMultiTexCoord3iv", lib);
        bindFunc(glMultiTexCoord3s)("glMultiTexCoord3s", lib);
        bindFunc(glMultiTexCoord3sv)("glMultiTexCoord3sv", lib);
        bindFunc(glMultiTexCoord4d)("glMultiTexCoord4d", lib);
        bindFunc(glMultiTexCoord4dv)("glMultiTexCoord4dv", lib);
        bindFunc(glMultiTexCoord4f)("glMultiTexCoord4f", lib);
        bindFunc(glMultiTexCoord4fv)("glMultiTexCoord4fv", lib);
        bindFunc(glMultiTexCoord4i)("glMultiTexCoord4i", lib);
        bindFunc(glMultiTexCoord4iv)("glMultiTexCoord4iv", lib);
        bindFunc(glMultiTexCoord4s)("glMultiTexCoord4s", lib);
        bindFunc(glMultiTexCoord4sv)("glMultiTexCoord4sv", lib);
        bindFunc(glLoadTransposeMatrixd)("glLoadTransposeMatrixd", lib);
        bindFunc(glLoadTransposeMatrixf)("glLoadTransposeMatrixf", lib);
        bindFunc(glMultTransposeMatrixd)("glMultTransposeMatrixd", lib);
        bindFunc(glMultTransposeMatrixf)("glMultTransposeMatrixf", lib);
        bindFunc(glSampleCoverage)("glSampleCoverage", lib);
        bindFunc(glCompressedTexImage1D)("glCompressedTexImage1D", lib);
        bindFunc(glCompressedTexImage2D)("glCompressedTexImage2D", lib);
        bindFunc(glCompressedTexImage3D)("glCompressedTexImage3D", lib);
        bindFunc(glCompressedTexSubImage1D)("glCompressedTexSubImage1D", lib);
        bindFunc(glCompressedTexSubImage2D)("glCompressedTexSubImage2D", lib);
        bindFunc(glCompressedTexSubImage3D)("glCompressedTexSubImage3D", lib);
        bindFunc(glGetCompressedTexImage)("glGetCompressedTexImage", lib);
    }
}

const GLuint GL_TEXTURE0                    = 0x84C0;
const GLuint GL_TEXTURE1                    = 0x84C1;
const GLuint GL_TEXTURE2                    = 0x84C2;
const GLuint GL_TEXTURE3                    = 0x84C3;
const GLuint GL_TEXTURE4                    = 0x84C4;
const GLuint GL_TEXTURE5                    = 0x84C5;
const GLuint GL_TEXTURE6                    = 0x84C6;
const GLuint GL_TEXTURE7                    = 0x84C7;
const GLuint GL_TEXTURE8                    = 0x84C8;
const GLuint GL_TEXTURE9                    = 0x84C9;
const GLuint GL_TEXTURE10                   = 0x84CA;
const GLuint GL_TEXTURE11                   = 0x84CB;
const GLuint GL_TEXTURE12                   = 0x84CC;
const GLuint GL_TEXTURE13                   = 0x84CD;
const GLuint GL_TEXTURE14                   = 0x84CE;
const GLuint GL_TEXTURE15                   = 0x84CF;
const GLuint GL_TEXTURE16                   = 0x84D0;
const GLuint GL_TEXTURE17                   = 0x84D1;
const GLuint GL_TEXTURE18                   = 0x84D2;
const GLuint GL_TEXTURE19                   = 0x84D3;
const GLuint GL_TEXTURE20                   = 0x84D4;
const GLuint GL_TEXTURE21                   = 0x84D5;
const GLuint GL_TEXTURE22                   = 0x84D6;
const GLuint GL_TEXTURE23                   = 0x84D7;
const GLuint GL_TEXTURE24                   = 0x84D8;
const GLuint GL_TEXTURE25                   = 0x84D9;
const GLuint GL_TEXTURE26                   = 0x84DA;
const GLuint GL_TEXTURE27                   = 0x84DB;
const GLuint GL_TEXTURE28                   = 0x84DC;
const GLuint GL_TEXTURE29                   = 0x84DD;
const GLuint GL_TEXTURE30                   = 0x84DE;
const GLuint GL_TEXTURE31                   = 0x84DF;
const GLuint GL_ACTIVE_TEXTURE              = 0x84E0;
const GLuint GL_CLIENT_ACTIVE_TEXTURE       = 0x84E1;
const GLuint GL_MAX_TEXTURE_UNITS           = 0x84E2;
const GLuint GL_NORMAL_MAP                  = 0x8511;
const GLuint GL_REFLECTION_MAP              = 0x8512;
const GLuint GL_TEXTURE_CUBE_MAP            = 0x8513;
const GLuint GL_TEXTURE_BINDING_CUBE_MAP    = 0x8514;
const GLuint GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
const GLuint GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
const GLuint GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
const GLuint GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
const GLuint GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
const GLuint GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
const GLuint GL_PROXY_TEXTURE_CUBE_MAP      = 0x851B;
const GLuint GL_MAX_CUBE_MAP_TEXTURE_SIZE   = 0x851C;
const GLuint GL_COMPRESSED_ALPHA            = 0x84E9;
const GLuint GL_COMPRESSED_LUMINANCE        = 0x84EA;
const GLuint GL_COMPRESSED_LUMINANCE_ALPHA  = 0x84EB;
const GLuint GL_COMPRESSED_INTENSITY        = 0x84EC;
const GLuint GL_COMPRESSED_RGB              = 0x84ED;
const GLuint GL_COMPRESSED_RGBA             = 0x84EE;
const GLuint GL_TEXTURE_COMPRESSION_HINT    = 0x84EF;
const GLuint GL_TEXTURE_COMPRESSED_IMAGE_SIZE   = 0x86A0;
const GLuint GL_TEXTURE_COMPRESSED      = 0x86A1;
const GLuint GL_NUM_COMPRESSED_TEXTURE_FORMATS  = 0x86A2;
const GLuint GL_COMPRESSED_TEXTURE_FORMATS  = 0x86A3;
const GLuint GL_MULTISAMPLE                 = 0x809D;
const GLuint GL_SAMPLE_ALPHA_TO_COVERAGE    = 0x809E;
const GLuint GL_SAMPLE_ALPHA_TO_ONE         = 0x809F;
const GLuint GL_SAMPLE_COVERAGE             = 0x80A0;
const GLuint GL_SAMPLE_BUFFERS              = 0x80A8;
const GLuint GL_SAMPLES                     = 0x80A9;
const GLuint GL_SAMPLE_COVERAGE_VALUE       = 0x80AA;
const GLuint GL_SAMPLE_COVERAGE_INVERT      = 0x80AB;
const GLuint GL_MULTISAMPLE_BIT             = 0x20000000;
const GLuint GL_TRANSPOSE_MODELVIEW_MATRIX  = 0x84E3;
const GLuint GL_TRANSPOSE_PROJECTION_MATRIX = 0x84E4;
const GLuint GL_TRANSPOSE_TEXTURE_MATRIX    = 0x84E5;
const GLuint GL_TRANSPOSE_COLOR_MATRIX      = 0x84E6;
const GLuint GL_COMBINE                     = 0x8570;
const GLuint GL_COMBINE_RGB                 = 0x8571;
const GLuint GL_COMBINE_ALPHA               = 0x8572;
const GLuint GL_SOURCE0_RGB                 = 0x8580;
const GLuint GL_SOURCE1_RGB                 = 0x8581;
const GLuint GL_SOURCE2_RGB                 = 0x8582;
const GLuint GL_SOURCE0_ALPHA               = 0x8588;
const GLuint GL_SOURCE1_ALPHA               = 0x8589;
const GLuint GL_SOURCE2_ALPHA               = 0x858A;
const GLuint GL_OPERAND0_RGB                = 0x8590;
const GLuint GL_OPERAND1_RGB                = 0x8591;
const GLuint GL_OPERAND2_RGB                = 0x8592;
const GLuint GL_OPERAND0_ALPHA              = 0x8598;
const GLuint GL_OPERAND1_ALPHA              = 0x8599;
const GLuint GL_OPERAND2_ALPHA              = 0x859A;
const GLuint GL_RGB_SCALE                   = 0x8573;
const GLuint GL_ADD_SIGNED                  = 0x8574;
const GLuint GL_INTERPOLATE                 = 0x8575;
const GLuint GL_SUBTRACT                    = 0x84E7;
const GLuint GL_CONSTANT                    = 0x8576;
const GLuint GL_PRIMARY_COLOR               = 0x8577;
const GLuint GL_PREVIOUS                    = 0x8578;
const GLuint GL_DOT3_RGB                    = 0x86AE;
const GLuint GL_DOT3_RGBA                   = 0x86AF;
const GLuint GL_CLAMP_TO_BORDER             = 0x812D;


version(Windows)
    extern(Windows):
else
    extern(C):

typedef GLvoid function(GLenum) pfglActiveTexture;
typedef GLvoid function(GLenum) pfglClientActiveTexture;
typedef GLvoid function(GLenum, GLdouble) pfglMultiTexCoord1d;
typedef GLvoid function(GLenum, GLdouble*) pfglMultiTexCoord1dv;
typedef GLvoid function(GLenum, GLfloat) pfglMultiTexCoord1f;
typedef GLvoid function(GLenum, GLfloat*) pfglMultiTexCoord1fv;
typedef GLvoid function(GLenum, GLint) pfglMultiTexCoord1i;
typedef GLvoid function(GLenum, GLint*) pfglMultiTexCoord1iv;
typedef GLvoid function(GLenum, GLshort) pfglMultiTexCoord1s;
typedef GLvoid function(GLenum, GLshort*) pfglMultiTexCoord1sv;
typedef GLvoid function(GLenum, GLdouble, GLdouble) pfglMultiTexCoord2d;
typedef GLvoid function(GLenum, GLdouble*) pfglMultiTexCoord2dv;
typedef GLvoid function(GLenum, GLfloat, GLfloat) pfglMultiTexCoord2f;
typedef GLvoid function(GLenum, GLfloat*) pfglMultiTexCoord2fv;
typedef GLvoid function(GLenum, GLint, GLint) pfglMultiTexCoord2i;
typedef GLvoid function(GLenum, GLint*) pfglMultiTexCoord2iv;
typedef GLvoid function(GLenum, GLshort, GLshort) pfglMultiTexCoord2s;
typedef GLvoid function(GLenum, GLshort*) pfglMultiTexCoord2sv;
typedef GLvoid function(GLenum, GLdouble, GLdouble, GLdouble) pfglMultiTexCoord3d;
typedef GLvoid function(GLenum, GLdouble*) pfglMultiTexCoord3dv;
typedef GLvoid function(GLenum, GLfloat, GLfloat, GLfloat) pfglMultiTexCoord3f;
typedef GLvoid function(GLenum, GLfloat*) pfglMultiTexCoord3fv;
typedef GLvoid function(GLenum, GLint, GLint, GLint) pfglMultiTexCoord3i;
typedef GLvoid function(GLenum, GLint*) pfglMultiTexCoord3iv;
typedef GLvoid function(GLenum, GLshort, GLshort, GLshort) pfglMultiTexCoord3s;
typedef GLvoid function(GLenum, GLshort*) pfglMultiTexCoord3sv;
typedef GLvoid function(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) pfglMultiTexCoord4d;
typedef GLvoid function(GLenum, GLdouble*) pfglMultiTexCoord4dv;
typedef GLvoid function(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) pfglMultiTexCoord4f;
typedef GLvoid function(GLenum, GLfloat*) pfglMultiTexCoord4fv;
typedef GLvoid function(GLenum, GLint, GLint, GLint, GLint) pfglMultiTexCoord4i;
typedef GLvoid function(GLenum, GLint*) pfglMultiTexCoord4iv;
typedef GLvoid function(GLenum, GLshort, GLshort, GLshort, GLshort) pfglMultiTexCoord4s;
typedef GLvoid function(GLenum, GLshort*) pfglMultiTexCoord4sv;
typedef GLvoid function(GLdouble[16]) pfglLoadTransposeMatrixd;
typedef GLvoid function(GLfloat[16]) pfglLoadTransposeMatrixf;
typedef GLvoid function(GLdouble[16]) pfglMultTransposeMatrixd;
typedef GLvoid function(GLfloat[16]) pfglMultTransposeMatrixf;
typedef GLvoid function(GLclampf, GLboolean) pfglSampleCoverage;
typedef GLvoid function(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoid*) pfglCompressedTexImage1D;
typedef GLvoid function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoid*) pfglCompressedTexImage2D;
typedef GLvoid function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei depth, GLint, GLsizei, GLvoid*) pfglCompressedTexImage3D;
typedef GLvoid function(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoid*) pfglCompressedTexSubImage1D;
typedef GLvoid function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoid*) pfglCompressedTexSubImage2D;
typedef GLvoid function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoid*) pfglCompressedTexSubImage3D;
typedef GLvoid function(GLenum, GLint, GLvoid*) pfglGetCompressedTexImage;

pfglActiveTexture           glActiveTexture;
pfglClientActiveTexture     glClientActiveTexture;
pfglMultiTexCoord1d         glMultiTexCoord1d;
pfglMultiTexCoord1dv        glMultiTexCoord1dv;
pfglMultiTexCoord1f         glMultiTexCoord1f;
pfglMultiTexCoord1fv        glMultiTexCoord1fv;
pfglMultiTexCoord1i         glMultiTexCoord1i;
pfglMultiTexCoord1iv        glMultiTexCoord1iv;
pfglMultiTexCoord1s         glMultiTexCoord1s;
pfglMultiTexCoord1sv        glMultiTexCoord1sv;
pfglMultiTexCoord2d         glMultiTexCoord2d;
pfglMultiTexCoord2dv        glMultiTexCoord2dv;
pfglMultiTexCoord2f         glMultiTexCoord2f;
pfglMultiTexCoord2fv        glMultiTexCoord2fv;
pfglMultiTexCoord2i         glMultiTexCoord2i;
pfglMultiTexCoord2iv        glMultiTexCoord2iv;
pfglMultiTexCoord2s         glMultiTexCoord2s;
pfglMultiTexCoord2sv        glMultiTexCoord2sv;
pfglMultiTexCoord3d         glMultiTexCoord3d;
pfglMultiTexCoord3dv        glMultiTexCoord3dv;
pfglMultiTexCoord3f         glMultiTexCoord3f;
pfglMultiTexCoord3fv        glMultiTexCoord3fv;
pfglMultiTexCoord3i         glMultiTexCoord3i;
pfglMultiTexCoord3iv        glMultiTexCoord3iv;
pfglMultiTexCoord3s         glMultiTexCoord3s;
pfglMultiTexCoord3sv        glMultiTexCoord3sv;
pfglMultiTexCoord4d         glMultiTexCoord4d;
pfglMultiTexCoord4dv        glMultiTexCoord4dv;
pfglMultiTexCoord4f         glMultiTexCoord4f;
pfglMultiTexCoord4fv        glMultiTexCoord4fv;
pfglMultiTexCoord4i         glMultiTexCoord4i;
pfglMultiTexCoord4iv        glMultiTexCoord4iv;
pfglMultiTexCoord4s         glMultiTexCoord4s;
pfglMultiTexCoord4sv        glMultiTexCoord4sv;
pfglLoadTransposeMatrixd    glLoadTransposeMatrixd;
pfglLoadTransposeMatrixf    glLoadTransposeMatrixf;
pfglMultTransposeMatrixd    glMultTransposeMatrixd;
pfglMultTransposeMatrixf    glMultTransposeMatrixf;
pfglSampleCoverage          glSampleCoverage;
pfglCompressedTexImage1D    glCompressedTexImage1D;
pfglCompressedTexImage2D    glCompressedTexImage2D;
pfglCompressedTexImage3D    glCompressedTexImage3D;
pfglCompressedTexSubImage1D glCompressedTexSubImage1D;
pfglCompressedTexSubImage2D glCompressedTexSubImage2D;
pfglCompressedTexSubImage3D glCompressedTexSubImage3D;
pfglGetCompressedTexImage   glGetCompressedTexImage;
